/***************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.
This code is licensed under the Visual Studio SDK license terms.
THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.

***************************************************************************/

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.OLE.Interop;
using System.Security.Permissions;
using System.Diagnostics.CodeAnalysis;

namespace Microsoft.VisualStudio.Package
{
	internal enum tagDVASPECT
	{
		DVASPECT_CONTENT = 1,
		DVASPECT_THUMBNAIL = 2,
		DVASPECT_ICON = 4,
		DVASPECT_DOCPRINT = 8
	}

	internal enum tagTYMED
	{
		TYMED_HGLOBAL = 1,
		TYMED_FILE = 2,
		TYMED_ISTREAM = 4,
		TYMED_ISTORAGE = 8,
		TYMED_GDI = 16,
		TYMED_MFPICT = 32,
		TYMED_ENHMF = 64,
		TYMED_NULL = 0
	}

	internal sealed class DataCacheEntry : IDisposable
	{
		#region fields
		/// <summary>
		/// Defines an object that will be a mutex for this object for synchronizing thread calls.
		/// </summary>
		private static volatile object Mutex = new object();

		private FORMATETC format;

		private long data;

		private DATADIR dataDir;

		private bool isDisposed;
		#endregion

		#region properties
		internal FORMATETC Format
		{
			get
			{
				return this.format;
			}
		}

		internal long Data
		{
			get
			{
				return this.data;
			}
		}

		[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
		internal DATADIR DataDir
		{
			get
			{
				return this.dataDir;
			}
		}

		#endregion

		/// <summary>
		/// The IntPtr is data allocated that should be removed. It is allocated by the ProcessSelectionData method.
		/// </summary>
		internal DataCacheEntry(FORMATETC fmt, IntPtr data, DATADIR dir)
		{
			this.format = fmt;
			this.data = (long)data;
			this.dataDir = dir;
		}

		#region Dispose
		~DataCacheEntry()
		{
			Dispose(false);
		}

		/// <summary>
		/// The IDispose interface Dispose method for disposing the object determinastically.
		/// </summary>
		public void Dispose()
		{
			Dispose(true);
			GC.SuppressFinalize(this);
		}

		/// <summary>
		/// The method that does the cleanup.
		/// </summary>
		/// <param name="disposing"></param>
		private void Dispose(bool disposing)
		{
			// Everybody can go here.
			if (!this.isDisposed)
			{
				// Synchronize calls to the Dispose simulteniously.
				lock (Mutex)
				{

					if (this.data != 0)
					{
						Marshal.FreeHGlobal((IntPtr)this.data);
						this.data = 0;
					}

					this.isDisposed = true;
				}
			}
		}
		#endregion
	}

	/// <summary>
	/// Unfortunately System.Windows.Forms.IDataObject and
	/// Microsoft.VisualStudio.OLE.Interop.IDataObject are different...
	/// </summary>
	internal sealed class DataObject : IDataObject
	{
		#region fields
		internal const int DATA_S_SAMEFORMATETC = 0x00040130;

		internal static readonly int DATA_E_FORMATETC = ForceCast(0x80040064);

		EventSinkCollection map;

		ArrayList entries;
		#endregion

		internal DataObject()
		{
			this.map = new EventSinkCollection();
			this.entries = new ArrayList();
		}

		internal void SetData(FORMATETC format, IntPtr data)
		{
			this.entries.Add(new DataCacheEntry(format, data, DATADIR.DATADIR_SET));
		}

		#region IDataObject methods
		int IDataObject.DAdvise(FORMATETC[] e, uint adv, IAdviseSink sink, out uint cookie)
		{
			STATDATA sdata = new STATDATA();

			sdata.ADVF = adv;
			sdata.FORMATETC = e[0];
			sdata.pAdvSink = sink;
			cookie = this.map.Add(sdata);
			sdata.dwConnection = cookie;
			return 0;
		}

		void IDataObject.DUnadvise(uint cookie)
		{
			this.map.RemoveAt(cookie);
		}

		int IDataObject.EnumDAdvise(out IEnumSTATDATA e)
		{
			e = new EnumSTATDATA((IEnumerable)this.map);
			return 0; //??
		}

		int IDataObject.EnumFormatEtc(uint direction, out IEnumFORMATETC penum)
		{
			penum = new EnumFORMATETC((DATADIR)direction, (IEnumerable)this.entries);
			return 0;
		}

		int IDataObject.GetCanonicalFormatEtc(FORMATETC[] format, FORMATETC[] fmt)
		{
			throw new System.Runtime.InteropServices.COMException("", DATA_S_SAMEFORMATETC);
		}

		void IDataObject.GetData(FORMATETC[] fmt, STGMEDIUM[] m)
		{
			STGMEDIUM retMedium = new STGMEDIUM();

			if (fmt == null || fmt.Length < 1)
				return;

			foreach (DataCacheEntry e in this.entries)
			{
				if (e.Format.cfFormat == fmt[0].cfFormat /*|| fmt[0].cfFormat == InternalNativeMethods.CF_HDROP*/)
				{
					retMedium.tymed = e.Format.tymed;

					// Caller must delete the memory.
					retMedium.unionmember = DragDropHelper.CopyHGlobal(new IntPtr(e.Data));
					break;
				}
			}

			if (m != null && m.Length > 0)
				m[0] = retMedium;
		}

		void IDataObject.GetDataHere(FORMATETC[] fmt, STGMEDIUM[] m)
		{
		}

		int IDataObject.QueryGetData(FORMATETC[] fmt)
		{
			if (fmt == null || fmt.Length < 1)
				return VSConstants.S_FALSE;

			foreach (DataCacheEntry e in this.entries)
			{
				if (e.Format.cfFormat == fmt[0].cfFormat /*|| fmt[0].cfFormat == InternalNativeMethods.CF_HDROP*/)
					return VSConstants.S_OK;
			}

			return VSConstants.S_FALSE;
		}

		void IDataObject.SetData(FORMATETC[] fmt, STGMEDIUM[] m, int fRelease)
		{
		}
		#endregion

		#region static methods
		internal static int ForceCast(uint i)
		{
			unchecked { return (int)i; }
		}

		internal static uint ForceCast(int i)
		{
			unchecked { return (uint)i; }
		}

		#endregion
	}

	[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
	internal static class DragDropHelper
	{
#pragma warning disable 414
		internal static readonly ushort CF_VSREFPROJECTS = 0;
		internal static readonly ushort CF_VSSTGPROJECTS = 0;
		internal static readonly ushort CF_VSREFPROJECTITEMS = 0;
		internal static readonly ushort CF_VSSTGPROJECTITEMS = 0;
		internal static readonly ushort CF_PROJECTCLIPDESCRIPTOR = 0;
		internal static readonly ushort CF_VSPROJECTCLIPDESCRIPTOR = 0;
#pragma warning restore 414

		static DragDropHelper()
		{
			CF_VSREFPROJECTS = UnsafeNativeMethods.RegisterClipboardFormat("CF_VSREFPROJECTS");
			CF_VSSTGPROJECTS = UnsafeNativeMethods.RegisterClipboardFormat("CF_VSSTGPROJECTS");
			CF_VSREFPROJECTITEMS = UnsafeNativeMethods.RegisterClipboardFormat("CF_VSREFPROJECTITEMS");
			CF_VSSTGPROJECTITEMS = UnsafeNativeMethods.RegisterClipboardFormat("CF_VSSTGPROJECTITEMS");
			CF_VSPROJECTCLIPDESCRIPTOR = UnsafeNativeMethods.RegisterClipboardFormat("CF_PROJECTCLIPBOARDDESCRIPTOR");
		}


		public static FORMATETC CreateFormatEtc(ushort iFormat)
		{
			FORMATETC fmt = new FORMATETC();
			fmt.cfFormat = iFormat;
			fmt.ptd = IntPtr.Zero;
			fmt.dwAspect = (uint)DVASPECT.DVASPECT_CONTENT;
			fmt.lindex = -1;
			fmt.tymed = (uint)TYMED.TYMED_HGLOBAL;
			return fmt;
		}

		public static FORMATETC CreateFormatEtc()
		{
			return CreateFormatEtc(CF_VSSTGPROJECTITEMS);
		}

		public static int QueryGetData(Microsoft.VisualStudio.OLE.Interop.IDataObject pDataObject, ref FORMATETC fmtetc)
		{
			int returnValue = VSConstants.E_FAIL;
			FORMATETC[] af = new FORMATETC[1];
			af[0] = fmtetc;
			try
			{
				int result = ErrorHandler.ThrowOnFailure(pDataObject.QueryGetData(af));
				if (result == VSConstants.S_OK)
				{
					fmtetc = af[0];
					returnValue = VSConstants.S_OK;
				}
			}
			catch (COMException e)
			{
				Trace.WriteLine("COMException : " + e.Message);
				returnValue = e.ErrorCode;
			}

			return returnValue;
		}

		public static STGMEDIUM GetData(Microsoft.VisualStudio.OLE.Interop.IDataObject pDataObject, ref FORMATETC fmtetc)
		{
			FORMATETC[] af = new FORMATETC[1];
			af[0] = fmtetc;
			STGMEDIUM[] sm = new STGMEDIUM[1];
			pDataObject.GetData(af, sm);
			fmtetc = af[0];
			return sm[0];
		}

		/// <summary>
		/// Retrives data from a VS format.
		/// </summary>
		public static List<string> GetDroppedFiles(ushort format, Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject, out DropDataType ddt)
		{
			ddt = DropDataType.None;
			List<string> droppedFiles = new List<string>();

			// try HDROP
			FORMATETC fmtetc = CreateFormatEtc(format);

			if (QueryGetData(dataObject, ref fmtetc) == VSConstants.S_OK)
			{
				STGMEDIUM stgmedium = DragDropHelper.GetData(dataObject, ref fmtetc);
				if (stgmedium.tymed == (uint)TYMED.TYMED_HGLOBAL)
				{
					// We are releasing the cloned hglobal here.
					IntPtr dropInfoHandle = stgmedium.unionmember;
					if (dropInfoHandle != IntPtr.Zero)
					{
						ddt = DropDataType.Shell;
						try
						{
							uint numFiles = UnsafeNativeMethods.DragQueryFile(dropInfoHandle, 0xFFFFFFFF, null, 0);

							// We are a directory based project thus a projref string is placed on the clipboard.
							// We assign the maximum length of a projref string.
							// The format of a projref is : <Proj Guid>|<project rel path>|<file path>
							uint lenght = (uint)Guid.Empty.ToString().Length + 2 * NativeMethods.MAX_PATH + 2;
							char[] moniker = new char[lenght + 1];
							for (uint fileIndex = 0; fileIndex < numFiles; fileIndex++)
							{
								uint queryFileLength = UnsafeNativeMethods.DragQueryFile(dropInfoHandle, fileIndex, moniker, lenght);
								string filename = new String(moniker, 0, (int)queryFileLength);
								droppedFiles.Add(filename);
							}
						}
						finally
						{
							Marshal.FreeHGlobal(dropInfoHandle);
						}
					}
				}
			}

			return droppedFiles;
		}



		public static string GetSourceProjectPath(Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject)
		{
			string projectPath = null;
			FORMATETC fmtetc = CreateFormatEtc(CF_VSPROJECTCLIPDESCRIPTOR);

			if (QueryGetData(dataObject, ref fmtetc) == VSConstants.S_OK)
			{
				STGMEDIUM stgmedium = DragDropHelper.GetData(dataObject, ref fmtetc);
				if (stgmedium.tymed == (uint)TYMED.TYMED_HGLOBAL)
				{
					// We are releasing the cloned hglobal here.
					IntPtr dropInfoHandle = stgmedium.unionmember;
					if (dropInfoHandle != IntPtr.Zero)
					{
						try
						{
							string path = GetData(dropInfoHandle);

							// Clone the path that we can release our memory.
							if (!String.IsNullOrEmpty(path))
							{
								projectPath = String.Copy(path);
							}
						}
						finally
						{
							Marshal.FreeHGlobal(dropInfoHandle);
						}
					}
				}
			}

			return projectPath;
		}

		/// <summary>
		/// Returns the data packed after the DROPFILES structure.
		/// </summary>
		/// <param name="dropHandle"></param>
		/// <returns></returns>
		internal static string GetData(IntPtr dropHandle)
		{
			IntPtr data = UnsafeNativeMethods.GlobalLock(dropHandle);
			try
			{
				_DROPFILES df = (_DROPFILES)Marshal.PtrToStructure(data, typeof(_DROPFILES));
				if (df.fWide != 0)
				{
					IntPtr pdata = new IntPtr((long)data + df.pFiles);
					return Marshal.PtrToStringUni(pdata);
				}
			}
			finally
			{
				if (data != null)
				{
					UnsafeNativeMethods.GlobalUnLock(data);
				}
			}

			return null;
		}

		internal static void FillFormatEtc(ref FORMATETC template, ushort clipFormat, ref FORMATETC result)
		{
			if (clipFormat != 0)
			{
				result = template;
				result.cfFormat = clipFormat;
				result.ptd = IntPtr.Zero;
				result.dwAspect = (uint)DVASPECT.DVASPECT_CONTENT;
				result.lindex = -1;
				result.tymed = (uint)TYMED.TYMED_NULL;
			}
		}

		internal static void OleCopyFormatEtc(ref FORMATETC src, ref FORMATETC dest)
		{
			dest.cfFormat = src.cfFormat;
			dest.ptd = Marshal.AllocCoTaskMem(Marshal.SizeOf(src.ptd));
			Marshal.StructureToPtr(src.ptd, dest.ptd, false);
			dest.dwAspect = src.dwAspect;
			dest.lindex = src.lindex;
			dest.tymed = src.tymed;
		}

		internal static IntPtr CopyHGlobal(IntPtr data)
		{
			IntPtr src = UnsafeNativeMethods.GlobalLock(data);
			int size = UnsafeNativeMethods.GlobalSize(data);
			IntPtr ptr = Marshal.AllocHGlobal(size);
			IntPtr buffer = UnsafeNativeMethods.GlobalLock(ptr);

			try
			{
				for (int i = 0; i < size; i++)
				{
					byte val = Marshal.ReadByte(new IntPtr((long)src + i));

					Marshal.WriteByte(new IntPtr((long)buffer + i), val);
				}
			}
			finally
			{
				if (buffer != IntPtr.Zero)
				{
					UnsafeNativeMethods.GlobalUnLock(buffer);
				}

				if (src != IntPtr.Zero)
				{
					UnsafeNativeMethods.GlobalUnLock(src);
				}
			}
			return ptr;
		}

		internal static void CopyStringToHGlobal(string s, IntPtr data, int bufferSize)
		{
			Int16 nullTerminator = 0;
			int dwSize = Marshal.SizeOf(nullTerminator);

			if ((s.Length + 1) * Marshal.SizeOf(s[0]) > bufferSize)
				throw new System.IO.InternalBufferOverflowException();
			// IntPtr memory already locked...
			for (int i = 0, len = s.Length; i < len; i++)
			{
				Marshal.WriteInt16(data, i * dwSize, s[i]);
			}
			// NULL terminate it
			Marshal.WriteInt16(new IntPtr((long)data + (s.Length * dwSize)), nullTerminator);
		}

	} // end of dragdrophelper

	internal class EnumSTATDATA : IEnumSTATDATA
	{
		IEnumerable i;

		IEnumerator e;

		public EnumSTATDATA(IEnumerable i)
		{
			this.i = i;
			this.e = i.GetEnumerator();
		}

		void IEnumSTATDATA.Clone(out IEnumSTATDATA clone)
		{
			clone = new EnumSTATDATA(i);
		}

		int IEnumSTATDATA.Next(uint celt, STATDATA[] d, out uint fetched)
		{
			uint rc = 0;
			//uint size = (fetched != null) ? fetched[0] : 0;
			for (uint i = 0; i < celt; i++)
			{
				if (e.MoveNext())
				{
					STATDATA sdata = (STATDATA)e.Current;

					rc++;
					if (d != null && d.Length > i)
					{
						d[i] = sdata;
					}
				}
			}

			fetched = rc;
			return 0;
		}

		int IEnumSTATDATA.Reset()
		{
			e.Reset();
			return 0;
		}

		int IEnumSTATDATA.Skip(uint celt)
		{
			for (uint i = 0; i < celt; i++)
			{
				e.MoveNext();
			}

			return 0;
		}
	}

	internal class EnumFORMATETC : IEnumFORMATETC
	{
		IEnumerable cache; // of DataCacheEntrys.

		DATADIR dir;

		IEnumerator e;

		public EnumFORMATETC(DATADIR dir, IEnumerable cache)
		{
			this.cache = cache;
			this.dir = dir;
			e = cache.GetEnumerator();
		}

		void IEnumFORMATETC.Clone(out IEnumFORMATETC clone)
		{
			clone = new EnumFORMATETC(dir, cache);
		}

		int IEnumFORMATETC.Next(uint celt, FORMATETC[] d, uint[] fetched)
		{
			uint rc = 0;
			//uint size = (fetched != null) ? fetched[0] : 0;
			for (uint i = 0; i < celt; i++)
			{
				if (e.MoveNext())
				{
					DataCacheEntry entry = (DataCacheEntry)e.Current;

					rc++;
					if (d != null && d.Length > i)
					{
						d[i] = entry.Format;
					}
				}
				else
				{
					return VSConstants.S_FALSE;
				}
			}

			if (fetched != null && fetched.Length > 0)
				fetched[0] = rc;
			return VSConstants.S_OK;
		}

		int IEnumFORMATETC.Reset()
		{
			e.Reset();
			return 0;
		}

		int IEnumFORMATETC.Skip(uint celt)
		{
			for (uint i = 0; i < celt; i++)
			{
				e.MoveNext();
			}

			return 0;
		}
	}
}
